home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / benchmarks / pdev.mendel / timeIt.c < prev   
Encoding:
C/C++ Source or Header  |  1992-04-10  |  2.5 KB  |  116 lines
  1. /* $Header: /sprite/src/benchmarks/pdev.mendel/RCS/timeIt.c,v 1.2 92/04/10 15:52:44 kupfer Exp $ */
  2.  
  3. #include <stdio.h>
  4. #include <sys/types.h>
  5. #include <sys/file.h>
  6. #include <sys/time.h>
  7. #include <signal.h>
  8. #include "pdev.h"
  9.  
  10. ReturnStatus writeSrv();
  11. ReturnStatus readSvr();
  12.  
  13. static Pdev_CallBacks pdevDefaultCallBacks = {
  14.      NULL,
  15.      readSvr,
  16.      writeSrv,
  17.      NULL,
  18.      NULL,
  19.      NULL,
  20.      NULL,
  21. };
  22.  
  23. main(arv)
  24. {
  25.     register int i;
  26.     int    junk1, junk2;
  27.     int starttime;
  28.     struct timeval stp, etp;
  29.     Pdev_Token    pdev;
  30.     int        fd;
  31.     int        size;
  32.     int        pid;
  33.     char        buf[8192];
  34.     char        *pdevName;
  35.  
  36.     pdev = Pdev_Open("./pdevD", &pdevName, 9000, 0, &pdevDefaultCallBacks, 0);
  37.     if (pdev == (Pdev_Token) NULL) {
  38.         printf("Can't open pdev\n");
  39.         exit(1);
  40.     }
  41.     printf("Using pdev %s\n", pdevName);
  42.     pid = fork();
  43.     if (pid != 0) {
  44.         while(1) {
  45.         Fs_Dispatch();
  46.         }
  47.     }
  48.     fd = open(pdevName, O_RDWR, 0);
  49.     if (fd < 0) {
  50.         perror("open");
  51.         exit(1);
  52.     }
  53.     bzero(buf,8192);
  54.     for (size = 1; size <= 8192; size *= 2) {
  55.         gettimeofday(&stp,0);
  56.         for (i = 0; i < 1000; i++) {
  57.         if (write(fd, buf, size) != size) {
  58.             perror("write");
  59.         }
  60.         }
  61.         gettimeofday(&etp,0);
  62.         fixtime(&stp,&etp);
  63.         printf("Write %d bytes 1000 times , time = %4d.%03d\n", size,
  64.         etp.tv_sec, etp.tv_usec/1000);
  65.     }
  66.     for (size = 1; size <= 8192; size *= 2) {
  67.         gettimeofday(&stp,0);
  68.         for (i = 0; i < 1000; i++) {
  69.         if (read(fd, buf, size) != size) {
  70.             perror("read");
  71.         }
  72.         }
  73.         gettimeofday(&etp,0);
  74.         fixtime(&stp,&etp);
  75.         printf("Read %d bytes 1000 times , time = %4d.%-03d\n", size,
  76.         etp.tv_sec, etp.tv_usec/1000);
  77.     }
  78.     killpg(getpgrp(0),SIGTERM);
  79. }
  80. fixtime(s, e)
  81.         struct  timeval *s, *e;
  82. {
  83.  
  84.         e->tv_sec -= s->tv_sec;
  85.         e->tv_usec -= s->tv_usec;
  86.         if (e->tv_usec < 0) {
  87.                 e->tv_sec--; e->tv_usec += 1000000;
  88.         }
  89. }
  90.  
  91. ReturnStatus
  92. writeSrv(streamPtr, async, writePtr, selectBitsPtr, sigPtr)
  93.               Pdev_Stream *streamPtr;   
  94.               int async;                
  95.               Pdev_RWParam *writePtr;   
  96.               int *selectBitsPtr;       
  97.               Pdev_Signal *sigPtr;  
  98. {
  99.  
  100.     *selectBitsPtr = FS_READABLE | FS_WRITABLE;
  101.     return(SUCCESS);
  102. }
  103. ReturnStatus
  104. readSvr(streamPtr, readPtr, freeItPtr, selectBitsPtr, sigPtr)
  105.               Pdev_Stream *streamPtr;  
  106.               Pdev_RWParam *readPtr;   
  107.               Boolean *freeItPtr;       
  108.               int *selectBitsPtr;       
  109.               Pdev_Signal *sigPtr;      
  110. {
  111.     *freeItPtr = FALSE;
  112.     *selectBitsPtr = FS_READABLE | FS_WRITABLE;
  113.     return(SUCCESS);
  114.  
  115. }
  116.